﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace JeuDeDames_v1._02
{
    public class Damier
    {
        #region Constantes
        public const int BLANC = -1;
        public const int NOIR = 1;
        #endregion

        #region Propriétés
        public Joueur blanc;
        public Joueur noir;
        public int nbTour;
        public List<Coup> historiqueCoups;
        public Case[] damier;
        private int tourFinPartie= 1;         //info sur le tour pouvant amené à une fin de partie;
        private int nbTourAvFinPartie = 25; //nombre de tour sans modification déclarant la fin de partie;
        #endregion

        #region Constructeurs
        public Damier()
        {
            menu();
            historiqueCoups = new List<Coup>();
			if (blanc.nbPieces == 0 && noir.nbPieces == 0)
			{
				Console.Clear();
                int choix = 0;
				do
				{
                    try
                    {
                        Console.WriteLine("1- Plateau de Jeu pré-configuré\n2- Positionner les pieces");
                        choix = int.Parse(Console.ReadLine());
                        switch (choix)
                        {
                            case 1:
                                zoneTestPreConfig();
                                break;
                            case 2:
                                zoneTestChoisirPieces();
                                break;
                            default:
                                choix = 0;
                                break;
                        }
                    }
                    catch (FormatException) { choix = 0; }
                } while (choix == 0);
			}
        }
        public Damier(Joueur b, Joueur n)
        {
            this.blanc = b;
            this.noir = n;
            this.historiqueCoups = new List<Coup>();
            initDamier(); 
        }
        #endregion

        #region Méthodes
        #region Initialisation
        public void initDamier()
        {
            blanc.lesPieces.Clear();
            noir.lesPieces.Clear();
            damier = new Case[100];
            nbTour = 1;

            int i = 0;  //parcour toutes les cases du tableau, en modifiant 2 lignes en même temps (symétrie sur 2 lignes);
            int j = 0;  //parcour une ligne;

            /*---INITIALISATION DU DAMIER---*/
            while (i < 100)
            {
                if (j < 10) //si j n'est pas au bout d'une ligne
                {
                    /*Si sur la premiere ligne la case i est une case blanche*/
                    if (i % 10 == 0 || i % 10 == 2 || i % 10 == 4 || i % 10 == 6 || i % 10 == 8)
                    {
                        damier[i] = new CaseB(i);
                        if (i >= 0 && i <= 29)  //pions joueur noir
                        {
                            Piece unPion = new Pion(i + 10, noir);
                            damier[i + 10] = new CaseN(i + 10, unPion);
                            noir.lesPieces.Add(unPion);
                            noir.nbPieces++;
                        }
                        else if (i >= 60 && i <= 89) //pions joueur blanc
                        {
                            Piece unPion = new Pion(i + 10, blanc);
                            damier[i + 10] = new CaseN(i + 10, unPion);
                            blanc.lesPieces.Add(unPion);
                            blanc.nbPieces++;
                        }
                        else
                            damier[i + 10] = new CaseN(i + 10, null);
                    }
                    /*Si sur la premiere ligne la case i est une case noire*/
                    else if (i % 10 == 1 || i % 10 == 3 || i % 10 == 5 || i % 10 == 7 || i % 10 == 9)
                    {
                        damier[i + 10] = new CaseB(i + 10);
                        if (i >= 0 && i <= 29)
                        {
                            Piece unPion = new Pion(i, noir);
                            damier[i] = new CaseN(i, unPion);
                            noir.lesPieces.Add(unPion);
                            noir.nbPieces++;
                        }
                        else if (i >= 60 && i <= 89)
                        {
                            Piece unPion = new Pion(i, blanc);
                            damier[i] = new CaseN(i, unPion);
                            blanc.lesPieces.Add(unPion);
                            blanc.nbPieces++;
                        }
                        else
                            damier[i] = new CaseN(i, null);
                    }

                    i++;
                    j++;
                }
                else
                {
                    j = 0;
                    i += 10;
                }
            }
        }//initDamier();

        public void initDamierVide()
        {
            blanc.lesPieces.Clear();
            noir.lesPieces.Clear();
            damier = new Case[100];
            nbTour = 1;

            int i = 0;  //parcour toutes les cases du tableau, en modifiant 2 lignes en même temps (symétrie sur 2 lignes);
            int j = 0;  //parcour une ligne;

            /*---INITIALISATION DU DAMIER---*/
            while (i < 100)
            {
                if (j < 10) //si j n'est pas au bout d'une ligne
                {
                    /*Si sur la premiere ligne la case i est une case blanche*/
                    if (i % 10 == 0 || i % 10 == 2 || i % 10 == 4 || i % 10 == 6 || i % 10 == 8)
                    {
                        damier[i] = new CaseB(i);
                        damier[i + 10] = new CaseN(i + 10, null);
                    }
                    /*Si sur la premiere ligne la case i est une case noire*/
                    else if (i % 10 == 1 || i % 10 == 3 || i % 10 == 5 || i % 10 == 7 || i % 10 == 9)
                    {
                        damier[i + 10] = new CaseB(i + 10);
                        damier[i] = new CaseN(i, null);
                    }

                    i++;
                    j++;
                }
                else
                {
                    j = 0;
                    i += 10;
                }
            }
        }//initDamierVide();
        #endregion
        
        #region Affichages
        public void afficheDamier()
        {
            Console.Clear();
            Console.WriteLine("Tour : " + tourFinPartie + " Fin : " + nbTourAvFinPartie + "\n");
            Console.WriteLine("\t\tTour numéro " + ((nbTour + 2) / 2) + "\n");
            Console.WriteLine("      A   B   C   D   E   F   G   H   I   J    ");
            Console.WriteLine("     ___ ___ ___ ___ ___ ___ ___ ___ ___ ___   ");
            string ligne;
            int i = 0;
            for (int j = 0; j < 10; j++)
            {
                if (j < 9) { ligne = (j + 1) + " "; }
                else { ligne = (j + 1) + ""; }

                if (j == 2) // ligne où le nom du joueur noir est affiché
                {
                    Console.WriteLine(" " + ligne + " | " + damier[i]+" | "+damier[i+1]+" | "+damier[i+2]+" | "+damier[i+3]+" | "+damier[i+4]+" | "+damier[i+5]+" | "+damier[i+6]+" | "+damier[i+7]+" | "+damier[i+8]+" | "+damier[i+9]+" | "+" "+ligne+" "+noir.nom+" "+noir.nbPieces);
                    Console.WriteLine("    |___|___|___|___|___|___|___|___|___|___|  ");
                }
                else if (j == 7)    // ligne où le nom du joueur blanc est affiché
                {
                    Console.WriteLine(" " + ligne + " | " + damier[i] + " | " + damier[i + 1] + " | " + damier[i + 2] + " | " + damier[i + 3] + " | " + damier[i + 4] + " | " + damier[i + 5] + " | " + damier[i + 6] + " | " + damier[i + 7] + " | " + damier[i + 8] + " | " + damier[i + 9] + " | " + " " + ligne + " " + blanc.nom + " " + blanc.nbPieces);
                    Console.WriteLine("    |___|___|___|___|___|___|___|___|___|___|  ");
                }
                else
                {
                    Console.WriteLine(" " + ligne + " | " + damier[i] + " | " + damier[i + 1] + " | " + damier[i + 2] + " | " + damier[i + 3] + " | " + damier[i + 4] + " | " + damier[i + 5] + " | " + damier[i + 6] + " | " + damier[i + 7] + " | " + damier[i + 8] + " | " + damier[i + 9] + " | " + " " + ligne);
                    Console.WriteLine("    |___|___|___|___|___|___|___|___|___|___|  ");
                }
                i += 10;
            }
            Console.WriteLine("\n      A   B   C   D   E   F   G   H   I   J    ");
        }// afficheDamier();
        
        public void afficheHistorique()
        {
            Console.Write("Historique : ");
            foreach (Coup c in historiqueCoups)
            {
                Console.Write(c + " ");
            }
            Console.WriteLine("\n");
        }  
        #endregion

        #region Annulations
        public void annulerUnTour()
        {
            historiqueCoups.Reverse();
            List<Coup> newHistorique = new List<Coup>();
            foreach (Coup unCoup in historiqueCoups)
            {
                if (unCoup.nbTour == this.nbTour - 1)
                {
                    annulerCoup(unCoup);
                }
                else
                {
                    if (!newHistorique.Contains(unCoup))
                        newHistorique.Add(unCoup);
                }
            }
            nbTour -= 2;
            changerTour();
            newHistorique.Reverse();
            this.historiqueCoups = newHistorique;
            Console.WriteLine(historiqueCoups.Count());
        }

        public void annulerCoup(Coup coup)
        {
            if (coup.mange())
                annuleMange(coup);
            else if (!coup.mange())
                annuleSeDeplacer(coup);
        }

        private void annuleSeDeplacer(Coup coup)
        {
            coup.orig.piece = coup.dest.piece;
            coup.dest.piece = null;
            coup.orig.piece.pos = coup.orig.pos;
            afficheDamier();
        }

        private void annuleMange(Coup coup)
        {
            (this.damier[coup.orig.pos] as CaseN).piece = coup.dest.piece;
            (this.damier[coup.pMangee.pos] as CaseN).piece = coup.pPrise;
            (this.damier[coup.dest.pos] as CaseN).piece = null;
            if (!coup.pMangee.piece.j.lesPieces.Contains(coup.pPrise))
            {
                (this.damier[coup.pMangee.pos] as CaseN).piece.j.lesPieces.Add(coup.pPrise);
                (this.damier[coup.pMangee.pos] as CaseN).piece.j.nbPieces++;
            }
            coup.j.piecesMangees.Remove(coup.pMangee.pos);
            coup.orig.piece.pos = coup.orig.pos;
            this.afficheDamier();
        } 
        #endregion

        #region Jeu
        public void jouerUnTour()
        {
            //int pmax = 2;
            Coup coup = null;
            if (blanc.monTour == true)
            {

                Console.WriteLine("C'est au tour de " + this.blanc.nom + " :");
                //blanc.calculCoupsPossibles(this);
                blanc.afficheCoupsPossibles();
                if (blanc is Humain)
                {
                    coup = (blanc as Humain).coupAJouer(this);   //utilisateur rentre ses coordonnées. Celles-ci doivent correspondre à un coup présent dans la liste coupPossible
                }
                else if (blanc is Ordinateur)
                {
                    //coup = (blanc as Ordinateur).minMaxPremier(this);
                    coup = (blanc as Ordinateur).alphaBetaPremier(this);
                }
                blanc.jouer(this, ref coup);
                majTour(coup, coup.dest.piece);
                blanc.viderPiecesMangees(this);
            }
            else if (noir.monTour == true)
            {
                Console.WriteLine("C'est au tour de " + this.noir.nom + " :");
                //noir.calculCoupsPossibles(this);
                noir.afficheCoupsPossibles();
                if (noir is Humain)
                {
                    coup = (noir as Humain).coupAJouer(this);   //utilisateur rentre ses coordonnées. Celles-ci doivent correspondre à un coup présent dans la liste coupPossible
                }
                else if (noir is Ordinateur)
                {
                    //coup = (noir as Ordinateur).minMaxPremier(this);
                    coup = (noir as Ordinateur).alphaBetaPremier(this);
                }
                noir.jouer(this, ref coup);
                majTour(coup, coup.dest.piece);
                noir.viderPiecesMangees(this);
            }
            //historiqueCoups.Add(coup);
            afficheDamier();
            if (blanc.monTour)
            {
                /*Si la pièce joué est un pion, je regarde si sa nouvelle position est dans le tableau indices promotes*/
                if (((this.damier[coup.dest.pos] as CaseN).piece is Pion) && blanc.indicePromote.Contains(coup.dest.pos))
                    ((this.damier[coup.dest.pos] as CaseN).piece as Pion).promotion(this);
            }
            else if (noir.monTour)
            {
                /*Si la pièce joué est un pion, je regarde si sa nouvelle position est dans le tableau indices promotes*/
                if (((this.damier[coup.dest.pos] as CaseN).piece is Pion) && noir.indicePromote.Contains(coup.dest.pos))
                    ((this.damier[coup.dest.pos] as CaseN).piece as Pion).promotion(this);
            }
            changerTour();
        }

        public void changerTour()
        {
            bool temp = this.blanc.monTour;
            this.blanc.monTour = this.noir.monTour;
            this.noir.monTour = temp;
            this.nbTour++;
            if (this.blanc.monTour)
                this.blanc.calculCoupsPossibles(this);
            else
                this.noir.calculCoupsPossibles(this);
        }// changerTour();

        public int finPartie()
        {
            Joueur jcourant = null;
            Joueur adv = null;
            if (this.blanc.monTour == true)
            {
                jcourant = this.blanc;
                adv = this.noir;
            }
            else if (this.noir.monTour == true)
            {
                jcourant = this.noir;
                adv = this.blanc;
            }

            /*Si le joueur courant n'a plus de coups possibles*/
            if (jcourant.coupsPossibles.Count == 0)
            {
                return adv.couleur; //retourne la couleur adverse;
            }

            /*Si le joueur a, au moins, une dame en jeu, alors on peut tester les cas suivants de match nul.*/
            if (jcourant.nbDames > 0 && adv.nbDames > 0)
            {
                /*Si les pieces du joueur sont égales à 3 et celle adverse à 1 ou inverse*/
                if ((jcourant.nbPieces == 3 && adv.nbPieces == 1) || (adv.nbPieces == 3 && jcourant.nbPieces == 1))
                {
                    nbTourAvFinPartie = 16;
                }

                /*si il reste 2 dames d'un coté et 1 dame de l'autre.*/
                if ((jcourant.nbPieces == 2 && adv.nbPieces == 1) || (jcourant.nbPieces == 1 && adv.nbPieces == 2))
                    nbTourAvFinPartie = 5; //Le tour passe à 5.
                else if (jcourant.nbPieces == 1 && adv.nbPieces == 1)
                    nbTourAvFinPartie = 5; //Le tour passe à 5.

                /*Si le tourFinPartie a atteind le nbTourAvFinPartie*/
                if (tourFinPartie > nbTourAvFinPartie)
                {
                    return 2;
                }
            }
            /* Dans le cas où les deux joueurs ne possedent pas de dames.*/
            else
            {
                /* Si tourFinPartie > nbTourAvFinPartie.*/
                if (tourFinPartie > nbTourAvFinPartie)
                    return 2;
            }

            return 0;
        }//détermine la fin de Partie;

        private void majTour(Coup c, Piece pJouee)
        {
            if (pJouee is Pion || c.mange()) //Si pJouee est un Pion alors on raz, sinon on verfie que la dame a mangé.
            {
                if (nbTourAvFinPartie == 25)
                    tourFinPartie = 1;
                else
                    tourFinPartie++;
            }
            else
            {
                tourFinPartie++;
            }
        }
        #endregion

        #region Menus
        public void menu()
        {
            int choix = 0;
            int type = 0;
            string caseChoisi = "";
            string nom = "";
            int profondeur = 0;
            string nomIa = "";

            do
            {
                try
                {
                    Console.Clear();
                    Console.WriteLine("\t\tProjet Jeu de Dames v1.02 !\n");
                    Console.Write("TypedePartie\n\t1- Partie Normale\n\t2- Zone de test\nEntrez votre choix:\t");
                    string Type = Console.ReadLine();
                    type = int.Parse(Type);
                    switch (type)
                    {
                        case 1:
                            do
                            {
                                try
                                {
                                    Console.Clear();
                                    Console.WriteLine("Choix du type de jeu");
                                    Console.WriteLine("\t1- Humain vs Machine");
                                    Console.WriteLine("\t2- Humain vs Humain");
                                    Console.WriteLine("\t3- Machine vs Humain");
                                    Console.WriteLine("\t4- Machine vs Machine (le choc des titans !)");
                                    Console.Write("Entrez le numéro correspondant à votre choix : ");
                                    caseChoisi = Console.ReadLine();
                                    choix = int.Parse(caseChoisi);
                                    switch (choix)
                                    {
                                        case 1:
                                            nom = choisirNom();
                                            profondeur = choisirIA();
                                            nomIa = nomIA(profondeur);
                                            blanc = new Humain(BLANC, nom);
                                            noir = new Ordinateur(NOIR, profondeur, nomIa);
                                            break;
                                        case 2:
                                            nom = choisirNom();
                                            blanc = new Humain(BLANC, nom);
                                            nom = choisirNom();
                                            noir = new Humain(NOIR, nom);
                                            break;
                                        case 3:
                                            nom = choisirNom();
                                            profondeur = choisirIA();
                                            nomIa = nomIA(profondeur);
                                            blanc = new Ordinateur(BLANC, profondeur, nomIa);
                                            noir = new Humain(NOIR, nom);
                                            break;
                                        case 4:
                                            profondeur = choisirIA();
                                            nomIa = nomIA(profondeur);
                                            blanc = new Ordinateur(BLANC, profondeur, nomIa);
                                            profondeur = choisirIA();
                                            nomIa = nomIA(profondeur);
                                            noir = new Ordinateur(NOIR, profondeur, nomIa);
                                            break;
                                        default:
                                            choix = 0;
                                            break;
                                    }
                                }
                                catch (FormatException) { choix = 0; }
                            } while (choix == 0);
                            initDamier();
                            break;
                        case 2:
                            do
                            {
                                try
                                {
                                    Console.Clear();
                                    Console.WriteLine("Choix du type de jeu");
                                    Console.WriteLine("\t1- Humain vs Machine");
                                    Console.WriteLine("\t2- Humain vs Humain");
                                    Console.WriteLine("\t3- Machine vs Humain");
                                    Console.WriteLine("\t4- Machine vs Machine (le choc des titans !)");
                                    Console.Write("Entrez le numéro correspondant à votre choix : ");
                                    caseChoisi = Console.ReadLine();
                                    choix = int.Parse(caseChoisi);
                                    switch (choix)
                                    {
                                        case 1:
                                            nom = choisirNom();
                                            profondeur = choisirIA();
                                            nomIa = nomIA(profondeur);
                                            blanc = new Humain(BLANC, nom);
                                            noir = new Ordinateur(NOIR, profondeur, nomIa);
                                            break;
                                        case 2:
                                            nom = choisirNom();
                                            blanc = new Humain(BLANC, nom);
                                            nom = choisirNom();
                                            noir = new Humain(NOIR, nom);
                                            break;
                                        case 3:
                                            nom = choisirNom();
                                            profondeur = choisirIA();
                                            nomIa = nomIA(profondeur);
                                            blanc = new Ordinateur(BLANC, profondeur, nomIa);
                                            noir = new Humain(NOIR, nom);
                                            break;
                                        case 4:
                                            profondeur = choisirIA();
                                            nomIa = nomIA(profondeur);
                                            blanc = new Ordinateur(BLANC, profondeur, nomIa);
                                            profondeur = choisirIA();
                                            nomIa = nomIA(profondeur);
                                            noir = new Ordinateur(NOIR, profondeur, nomIa);
                                            break;
                                        default:
                                            choix = 0;
                                            break;
                                    }
                                }
                                catch (FormatException) { choix = 0; }
                            } while (choix == 0);
                            initDamierVide();
                            break;
                        default:
                            type = 0;
                            break;

                    }
                    
                }
                catch (System.FormatException) { type = 0; }
            } while (type == 0);
            return;
        }

        public string choisirNom()
        {
            Console.Clear();
            Console.WriteLine("Entrez votre prénom:");
            string nom = Console.ReadLine();
            return nom;
        }

        public int choisirIA()
        {
            Console.Clear();
            Console.WriteLine("1- Camille, Novice");
            Console.WriteLine("2- Christian, Moyen");
            Console.WriteLine("3- Vincent, Difficile");
            Console.WriteLine("4- Sébastien, Maître");
            Console.WriteLine("5- Josette, Destructeur de mondes");
            string choix = Console.ReadLine();
            int profondeur = 0;
            try
            {
                profondeur = int.Parse(choix);
            }
            catch(FormatException)
            {
                return choisirIA();
            }
            if (profondeur > 0 && profondeur < 6)
            {
                return profondeur;
            }
            else
            {
                return choisirIA();
            }
        }

        public string nomIA(int profondeur)
        {
            if (profondeur == 1) return "Camille";
            else if (profondeur == 2) return "Christian";
            else if (profondeur == 3) return "Vincent";
            else if (profondeur == 4) return "Sebastien";
            else return "Josette";
        }

        public void zoneTestChoisirPieces()
		{
			int nbPiece = 1;
			int nbPionsB = 0;
			int nbDamesB = 0;
			int nbPionsN = 0;
			int nbDamesN = 0;
			int pos = 0;
			do
			{
				try
				{
					afficheDamier();
					Console.WriteLine("Entrer le nombre de PIONS Blancs");
					nbPionsB = int.Parse(Console.ReadLine());
					Console.WriteLine("Entrer le nombre de DAMES Blanches");
					nbDamesB = int.Parse(Console.ReadLine());

					Console.WriteLine("Entrer le nombre de PIONS Noirs");
					nbPionsN = int.Parse(Console.ReadLine());
					Console.WriteLine("Entrer le nombre de DAMES Noires");
					nbDamesN = int.Parse(Console.ReadLine());
					nbPiece = 0;
				}
				catch (FormatException) { nbPiece = 1; }
            } while (nbPiece != 0);
            while (nbPiece < nbPionsB)
            {
				try
				{
					afficheDamier();
                    do
                    {
                        try
                        {
                            Console.Write("Entrer la position des Pions Blancs:\t");
                            pos = Coup.convertInt(Console.ReadLine());
                        }
                        catch(FormatException)
                        {
                            pos = 0;
                        }
                    } while (pos == 0);
                    (this.damier[pos] as CaseN).piece = new Pion(pos, blanc);
                    blanc.lesPieces.Add((this.damier[pos] as CaseN).piece);
                    blanc.nbPieces++;
                    nbPiece++;
				}
				catch (System.FormatException) { }
            }
            nbPiece = 0;
            while (nbPiece < nbPionsN)
            {
                    afficheDamier(); 
                    do
                    {
                        try
                        {
                            Console.Write("Entrer la position des Pions Noires:\t");
                            pos = Coup.convertInt(Console.ReadLine());
                        }
                        catch (FormatException)
                        {
                            pos = 0;
                        }
                    } while (pos == 0);
                    (this.damier[pos] as CaseN).piece = new Pion(pos, noir);
                    noir.lesPieces.Add((this.damier[pos] as CaseN).piece);
                    noir.nbPieces++;
                    nbPiece++;
            }
            nbPiece = 0;
            while (nbPiece < nbDamesN)
            {
                afficheDamier();
                do
                {
                    try
                    {
                        Console.Write("Entrer la position des Dames Noires:\t");
                        pos = Coup.convertInt(Console.ReadLine());
                    }
                    catch (FormatException)
                    {
                        pos = 0;
                    }
                } while (pos == 0);
                (this.damier[pos] as CaseN).piece = new Dame(pos, noir);
                noir.lesPieces.Add((this.damier[pos] as CaseN).piece);
                noir.nbPieces++;
                nbPiece++;
            }
            nbPiece = 0;
            while (nbPiece < nbDamesB)
            {
                afficheDamier();
                do
                {
                    try
                    {
                        Console.Write("Entrer la position des Dames Blanches:\t");
                        pos = Coup.convertInt(Console.ReadLine());
                    }
                    catch (FormatException)
                    {
                        pos = 0;
                    }
                } while (pos == 0);
                (this.damier[pos] as CaseN).piece = new Dame(pos, blanc);
                blanc.lesPieces.Add((this.damier[pos] as CaseN).piece);
                blanc.nbPieces++;
                nbPiece++;
            }
        }//demande à l'utilisateur de remplir le damier

		public void zoneTestPreConfig()
		{
			int choix = 0;
			List<int> pionsB = new List<int>();	//correspond à la liste des cases où se situe les pions blancs
			List<int> damesB = new List<int>(); //correspond à la liste des cases où se situe les dames blanches
			List<int> pionsN = new List<int>(); //correspond à la liste des cases où se situe les pions noirs
			List<int> damesN = new List<int>(); //correspond à la liste des cases où se situe les dames noires
			do
			{
				Console.Clear();
				Console.WriteLine("\t\tChoisir la situation de test\n\n"); 
				Console.WriteLine("1- Le plus grand mangeage multiple avec pions");
                Console.WriteLine("2- Le plus grand mangeage multiple avec dames");
                Console.WriteLine("3- Promotion");
                Console.WriteLine("4- Choix plusieurs cases mangeables");
                Console.WriteLine("5- Plusieurs mangeables avec pions");
                Console.WriteLine("6- Test mangeage multiple dans minMax ");
                Console.WriteLine("7- Situation problématique");
                choix = int.Parse(Console.ReadLine());
				switch (choix)
				{
					case 1:
						pionsB.Add(Coup.convertInt("E10"));	//E10
						pionsN.Add(Coup.convertInt("F9"));	//F9
						pionsN.Add(Coup.convertInt("H7"));	//H7
						pionsN.Add(Coup.convertInt("H5"));	//H5
						pionsN.Add(Coup.convertInt("D9"));	//D9
						damesN.Add(Coup.convertInt("B7"));	//B7
						break;
					case 2:
						damesB.Add(92);	//C10
						pionsN.Add(65);	//F7
                        pionsN.Add(67); //H7
						pionsN.Add(16);	//G2
						pionsN.Add(23);	//D3
                        pionsN.Add(87); //H9
						break;
                    case 3:
                        pionsB.Add(12); //C2
                        pionsN.Add(85); //F9
                        break;
                    case 4:
                        pionsB.Add(30); //A4
                        pionsB.Add(85); //F9
                        pionsN.Add(21); //B3
                        pionsN.Add(23); //D3
                        pionsN.Add(25); //F3
                        pionsN.Add(76); //G8
                        pionsN.Add(78); //I8
                        break;
                    case 5:
                        pionsN.Add(Coup.convertInt("C2"));
                        pionsN.Add(Coup.convertInt("C4"));
                        pionsN.Add(Coup.convertInt("E4"));
                        pionsN.Add(Coup.convertInt("F7"));
                        pionsB.Add(Coup.convertInt("G8"));
                        pionsB.Add(Coup.convertInt("F3"));
                        break;
                    case 6:
                        pionsN.Add(Coup.convertInt("C2"));
                        pionsN.Add(Coup.convertInt("C4"));
                        pionsN.Add(Coup.convertInt("E4"));
                        pionsB.Add(Coup.convertInt("E6"));
                        pionsB.Add(Coup.convertInt("D7"));
                        break;
                    case 7:
                        pionsB.Add(Coup.convertInt("B7"));
                        pionsB.Add(Coup.convertInt("C8"));
                        pionsB.Add(Coup.convertInt("C6"));
                        pionsB.Add(Coup.convertInt("D7"));
                        pionsN.Add(Coup.convertInt("E4"));
                        pionsN.Add(Coup.convertInt("D5"));
                        pionsN.Add(Coup.convertInt("F5"));
                        break;
					default:
						choix = 0;
						break;
				}
            } while (choix == 0);
			foreach (int p in pionsB)
			{
				(this.damier[p] as CaseN).piece = new Pion(p, this.blanc);
				this.blanc.lesPieces.Add((this.damier[p] as CaseN).piece);
                this.blanc.nbPieces++;
			}
			foreach (int p in damesB)
			{
				(this.damier[p] as CaseN).piece = new Dame(p, this.blanc);
				this.blanc.lesPieces.Add((this.damier[p] as CaseN).piece);
                this.blanc.nbPieces++;
			}
			foreach (int p in pionsN)
			{
				(this.damier[p] as CaseN).piece = new Pion(p, this.noir);
				this.noir.lesPieces.Add((this.damier[p] as CaseN).piece);
                this.noir.nbPieces++;
			}
			foreach (int p in damesN)
			{
				(this.damier[p] as CaseN).piece = new Dame(p, this.noir);
				this.noir.lesPieces.Add((this.damier[p] as CaseN).piece);
                this.noir.nbPieces++;
			}
		}
        #endregion

        #region Autres
        public Damier dupliquerDamier()
        {
            Damier unDamier = new Damier(this.blanc, this.noir);
            unDamier.MemberwiseClone();
            return unDamier;
        }
        #endregion

        #endregion
	}
}
